package com.gqh.weather.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.gqh.weather.config.FileConfig;
import com.gqh.weather.domain.dto.CcStudentLevelCount;
import com.gqh.weather.domain.dto.MyPage;
import com.gqh.weather.domain.dto.StudentExportDTO;
import com.gqh.weather.domain.dto.StudentListData;
import com.gqh.weather.domain.entity.CcSchoolStudentCount;
import com.gqh.weather.domain.entity.Student;
import com.gqh.weather.domain.entity.Task;
import com.gqh.weather.exception.BusinessException;
import com.gqh.weather.exception.Result;
import com.gqh.weather.mapper.CityMapper;
import com.gqh.weather.mapper.CcSchoolStudentCountMapper;
import com.gqh.weather.mapper.StudentMapper;
import com.gqh.weather.util.MinioUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

/**
 * 抽测学生管理服务类
 */
@Slf4j
@Service
public class CCStudentService extends ServiceImpl<StudentMapper, Student> {

//    @Autowired
//    private StudentMapper studentMapper;
//
//    @Autowired
//    private TaskService taskService;
//
//    @Autowired
//    private CityMapper cityMapper;
//
//    @Autowired
//    private CcSchoolStudentCountMapper ccSchoolStudentCountMapper;
//
//    @Autowired
//    private FileConfig fileConfig;
//
//    @Autowired
//    private MinioUtil minioUtil;
//
//    /**
//     * 抽测考生现场抽签
//     *
//     * @param taskId 任务id
//     * @return 抽签结果
//     */
//    @Transactional(rollbackFor = Exception.class)
//    public Result<Void> ccStudentExam(Integer taskId) {
//        try {
//            // 验证任务是否存在
//            if (taskId == null || taskId <= 0) {
//                return Result.error("任务id参数不正确");
//            }
//
//            Task task = taskService.getById(taskId);
//            if (task == null) {
//                return Result.error("任务不存在");
//            }
//
//            // 检查任务状态
//            if (task.getStudentState() == 0) {
//                return Result.error("考生列表未确认！");
//            }
//
//            if (task.getState() == 1 && task.getStartAt() != null && task.getStartAt() < System.currentTimeMillis() / 1000) {
//                return Result.error("考试已经开始，不可操作！");
//            }
//
//            // 重置抽签状态
//            LambdaUpdateWrapper<Student> resetWrapper = new LambdaUpdateWrapper<>();
//            resetWrapper.eq(Student::getTaskId, taskId);
//            resetWrapper.set(Student::getState, 0); // 0正常
//            studentMapper.update(null, resetWrapper);
//
//            // 获取设置抽签学校列表
//            LambdaQueryWrapper<CcSchoolStudentCount> ccSchoolWrapper = new LambdaQueryWrapper<>();
//            ccSchoolWrapper.eq(CcSchoolStudentCount::getTaskId, taskId);
//            ccSchoolWrapper.eq(CcSchoolStudentCount::getIsDeleted, 0);
//            List<CcSchoolStudentCount> ccSchoolList = ccSchoolStudentCountMapper.selectList(ccSchoolWrapper);
//
//            for (CcSchoolStudentCount s : ccSchoolList) {
//                Integer ccCount = s.getCcCount();
//                Integer schoolId = s.getSchoolId();
//
//                // 获取该学校该任务下的所有学生
//                LambdaQueryWrapper<Student> studentWrapper = new LambdaQueryWrapper<>();
//                studentWrapper.eq(Student::getTaskId, taskId);
//                studentWrapper.eq(Student::getSchoolId, schoolId);
//                studentWrapper.eq(Student::getIsDeleted, 0);
//                List<Student> stuList = studentMapper.selectList(studentWrapper);
//
//                int stuCount = stuList.size();
//                if (ccCount > stuCount) {
//                    // 学校设置抽测人数大于导入学生人数
//                    // 这里简化处理，实际项目中可能需要获取学校名称
//                    return Result.error(String.format("学校ID %d 设置的抽取人数为:%d,但该学校已导入的学生为:%d", schoolId, ccCount, stuCount));
//                }
//
//                if (ccCount.equals(stuCount)) {
//                    // 人数相同，此考场不用抽签，全部选中
//                    List<Integer> stuIds = new ArrayList<>();
//                    for (Student student : stuList) {
//                        stuIds.add(student.getId());
//                    }
//
//                    if (!stuIds.isEmpty()) {
//                        LambdaUpdateWrapper<Student> updateWrapper = new LambdaUpdateWrapper<>();
//                        updateWrapper.in(Student::getId, stuIds);
//                        updateWrapper.set(Student::getState, 1); // 1待考（被抽中）
//                        studentMapper.update(null, updateWrapper);
//                    }
//                } else {
//                    // 需要抽签
//                    // 获取每个等第的人数
//                    Map<Integer, CcStudentLevelCount> levelCount = new HashMap<>();
//                    levelCount.put(1, new CcStudentLevelCount());
//                    levelCount.put(2, new CcStudentLevelCount());
//                    levelCount.put(3, new CcStudentLevelCount());
//                    levelCount.put(4, new CcStudentLevelCount());
//
//                    for (Student slVal : stuList) {
//                        Integer level = slVal.getLevel();
//                        if (level == null || level <= 0 || level > 4) {
//                            level = 1;
//                        }
//                        levelCount.get(level).setCount(levelCount.get(level).getCount() + 1);
//                        levelCount.get(level).getStudents().add(slVal.getId());
//                    }
//
//                    int tmpDc = 0;
//                    for (Map.Entry<Integer, CcStudentLevelCount> entry : levelCount.entrySet()) {
//                        CcStudentLevelCount lcvt = entry.getValue();
//                        double per = (double) lcvt.getCount() * ccCount / stuCount;
//                        lcvt.setDc(round(per));
//                        if (lcvt.getDc() == 0) {
//                            if (lcvt.getCount() == 0) {
//                                continue;
//                            }
//                            lcvt.setDc(1);
//                        }
//                        tmpDc += lcvt.getDc();
//                    }
//
//                    int cz = ccCount - tmpDc;
//                    if (tmpDc < ccCount) {
//                        int tempCz = cz;
//                        for (int i = 1; i <= 4; i++) {
//                            levelCount.get(i).setDc(levelCount.get(i).getDc() + tempCz);
//                            if (levelCount.get(i).getDc() <= levelCount.get(i).getCount()) {
//                                break;
//                            }
//                            tempCz = levelCount.get(i).getDc() - levelCount.get(i).getCount();
//                            levelCount.get(i).setDc(levelCount.get(i).getCount());
//                        }
//                    } else if (tmpDc > ccCount) {
//                        int syRen = Math.abs(cz);
//                        int loopIdx = 0; // 防止死循环索引
//                        while (true) {
//                            for (int i = 4; i > 0; i--) {
//                                if (syRen == 0) {
//                                    break;
//                                }
//                                if (ccCount >= 4) {
//                                    if (levelCount.get(i).getDc() > 1) {
//                                        levelCount.get(i).setDc(levelCount.get(i).getDc() - 1);
//                                        syRen--;
//                                    }
//                                } else {
//                                    boolean bExist = false;
//                                    int j = 0;
//                                    // 查找是否存在大于1个的
//                                    for (j = 4; j > 0; j--) {
//                                        if (levelCount.get(j).getDc() > 1) {
//                                            bExist = true;
//                                            break;
//                                        }
//                                    }
//                                    if (bExist) {
//                                        levelCount.get(j).setDc(levelCount.get(j).getDc() - 1);
//                                        syRen--;
//                                        i = 5; // 继续从第一个查找
//                                    } else if (levelCount.get(i).getDc() > 0) {
//                                        levelCount.get(i).setDc(levelCount.get(i).getDc() - 1);
//                                        syRen--;
//                                    }
//                                }
//                            }
//                            loopIdx++;
//                            if (syRen == 0 || loopIdx > 1000000) {
//                                break;
//                            }
//                        }
//                    }
//
//                    // 抽取学生
//                    List<Integer> stuIdList = new ArrayList<>();
//                    Random rand = new Random();
//                    for (Map.Entry<Integer, CcStudentLevelCount> entry : levelCount.entrySet()) {
//                        CcStudentLevelCount lcv = entry.getValue();
//                        if (lcv.getDc() > 0) {
//                            List<Integer> lcvStu = new ArrayList<>(lcv.getStudents());
//                            List<Integer> stuIdListTmp = new ArrayList<>();
//                            for (int i = 0; i < lcv.getDc(); i++) {
//                                if (!lcvStu.isEmpty()) {
//                                    int idx = rand.nextInt(lcvStu.size());
//                                    stuIdListTmp.add(lcvStu.get(idx));
//                                    lcvStu.remove(idx);
//                                }
//                            }
//                            stuIdList.addAll(stuIdListTmp);
//                        }
//                    }
//
//                    // 设置学生状态
//                    if (!stuIdList.isEmpty()) {
//                        LambdaUpdateWrapper<Student> updateWrapper = new LambdaUpdateWrapper<>();
//                        updateWrapper.in(Student::getId, stuIdList);
//                        updateWrapper.set(Student::getState, 1); // 1待考（被抽中）
//                        studentMapper.update(null, updateWrapper);
//                    }
//                }
//            }
//
//            // 设置任务状态为已抽签
//            task.setStudentState(2);
//            taskService.updateById(task);
//
//            return Result.success(null);
//
//        } catch (Exception e) {
//            log.error("抽测考生现场抽签失败", e);
//            return Result.error("抽签失败：" + e.getMessage());
//        }
//    }
//
//    /**
//     * 四舍五入
//     *
//     * @param f 浮点数
//     * @return 四舍五入后的整数
//     */
//    private int round(double f) {
//        if (f < 0) {
//            return (int) (f - 0.5);
//        }
//        return (int) (f + 0.5);
//    }
//
//    /**
//     * 抽测考生导出
//     *
//     * @param taskId   任务id
//     * @param citycode 城市码
//     * @param userInfo 用户信息
//     * @return 导出结果
//     */
//    public Result<String> ccStudentExport(Integer taskId, String citycode, com.gqh.weather.auth.UserInfo userInfo) {
//        try {
//            // 验证参数
//            if (taskId == null || taskId <= 0) {
//                return Result.error("任务id参数不正确");
//            }
//
//            // 获取用户信息
//            String currentUserCitycode = userInfo.getCitycode();
//            String cityName = "";
//
//            if ("17170688".equals(currentUserCitycode)) {
//                cityName = "南京";
//            } else if ("17179088".equals(currentUserCitycode)) {
//                cityName = "焦作";
//            }
//
//            // 处理城市码逻辑
//            List<String> childCodes = new ArrayList<>();
//
//            if (StringUtils.hasText(citycode) && !citycode.equals(currentUserCitycode)) {
//                // 检查城市码是否在考评范围内
//                List<String> parentCodes = cityMapper.selectChildrenCodesByCode(currentUserCitycode);
//                boolean exist = parentCodes.contains(citycode);
//                if (!exist) {
//                    return Result.error("该地区码不在考评范围内");
//                }
//
//                // 获取子区域代码
//                childCodes.addAll(cityMapper.selectChildrenCodesByCode(citycode));
//                childCodes.add(citycode);
//
//                // 获取城市名称
//                com.gqh.weather.domain.entity.City city = cityMapper.selectByCode(citycode);
//                if (city != null && StringUtils.hasText(city.getName())) {
//                    cityName = city.getName();
//                } else {
//                    // 如果找不到城市信息，使用默认名称
//                    cityName = "城市_" + citycode;
//                }
//            }
//
//            // 查询学生数据
//            com.baomidou.mybatisplus.extension.plugins.pagination.Page<StudentListData> page =
//                new com.baomidou.mybatisplus.extension.plugins.pagination.Page<>(1, 10000); // 获取所有数据
//
//            // 使用自定义Mapper方法查询所有抽测学生
//            com.baomidou.mybatisplus.extension.plugins.pagination.Page<StudentListData> result =
//                studentMapper.selectStudentListWithDetails(
//                    page,
//                    taskId,
//                    1, // 状态：抽测学生
//                    null, // 学校ID：不限
//                    null, // 照片：不限
//                    null, // 关键字：无
//                    childCodes
//                );
//
//            List<StudentListData> studentList = result.getRecords();
//
//            // 转换为导出DTO
//            List<StudentExportDTO> exportList = new ArrayList<>();
//            for (StudentListData student : studentList) {
//                StudentExportDTO exportDTO = new StudentExportDTO();
//                exportDTO.setSchoolName(student.getSchoolName() != null ? student.getSchoolName() : "");
//                exportDTO.setName(student.getName() != null ? student.getName() : "");
//                exportDTO.setSex(getSexName(student.getSex()));
//                exportDTO.setStudentNo(student.getStudentNo() != null ? student.getStudentNo() : "");
//                exportDTO.setGrade(getGradeName(student.getGrade()));
//                exportDTO.setClazz(student.getClazz() != null ? student.getClazz() : "");
//                exportDTO.setLevel(getLevelName(student.getLevel()));
//                exportDTO.setExamAddressName(student.getExamAddressName() != null ? student.getExamAddressName() : "");
//                exportDTO.setExamRoomName(student.getExamRoomName() != null ? student.getExamRoomName() : "");
//                exportList.add(exportDTO);
//            }
//
//            // 生成文件名和路径
//            String timestamp = java.time.LocalDateTime.now().format(java.time.format.DateTimeFormatter.ofPattern("yyyy_MM_dd_HH_mm_ss"));
//            String fileName = cityName + "学生信息列表.xlsx";
//            String filePath = taskId + "_" + timestamp + "/" + fileName;
//            String fullFilePath = fileConfig.getExportDir() + "/" + filePath;
//
//            // 创建目录
//            java.nio.file.Path path = java.nio.file.Paths.get(fullFilePath);
//            java.nio.file.Files.createDirectories(path.getParent());
//
//            // 使用EasyExcel导出
//            com.alibaba.excel.EasyExcel.write(fullFilePath, StudentExportDTO.class)
//                .sheet("学生信息")
//                .doWrite(exportList);
//
//            // 返回文件访问URL
//            String url = fileConfig.getUrlPrefix() + "/" + filePath;
//            return Result.success(url);
//
//        } catch (Exception e) {
//            log.error("抽测考生导出失败", e);
//            return Result.error("导出失败：" + e.getMessage());
//        }
//    }
//
//    /**
//     * 获取性别名称
//     *
//     * @param sex 性别代码
//     * @return 性别名称
//     */
//    private String getSexName(Integer sex) {
//        if (sex == null) return "";
//        switch (sex) {
//            case 1: return "男";
//            case 2: return "女";
//            default: return "";
//        }
//    }
//
//    /**
//     * 获取年级名称
//     *
//     * @param grade 年级代码
//     * @return 年级名称
//     */
//    private String getGradeName(Integer grade) {
//        if (grade == null) return "";
//        // 这里简化处理，实际项目中可能需要从枚举或其他配置中获取
//        switch (grade) {
//            case 1: return "一年级";
//            case 2: return "二年级";
//            case 3: return "三年级";
//            case 4: return "四年级";
//            case 5: return "五年级";
//            case 6: return "六年级";
//            case 7: return "初一";
//            case 8: return "初二";
//            case 9: return "初三";
//            case 10: return "高一";
//            case 11: return "高二";
//            case 12: return "高三";
//            default: return grade.toString();
//        }
//    }
//
//    /**
//     * 获取等第名称
//     *
//     * @param level 等第代码
//     * @return 等第名称
//     */
//    private String getLevelName(Integer level) {
//        if (level == null) return "";
//        switch (level) {
//            case 1: return "A";
//            case 2: return "B";
//            case 3: return "C";
//            case 4: return "D";
//            default: return "";
//        }
//    }
//
//    /**
//     * 抽测考生照片导出
//     *
//     * @param taskId   任务id
//     * @param isAll    0按学校分文件夹导出 1不分文件夹全部导出
//     * @param citycode 城市码
//     * @param userInfo 用户信息
//     * @return 导出结果
//     */
//    public Result<String> ccStudentExportPic(Integer taskId, Integer isAll, String citycode, com.gqh.weather.auth.UserInfo userInfo) {
//        try {
//            // 验证参数
//            if (taskId == null || taskId <= 0) {
//                return Result.error("任务id参数不正确");
//            }
//
//            if (isAll == null || (isAll != 0 && isAll != 1)) {
//                return Result.error("导出方式参数不正确");
//            }
//
//            // 获取用户信息
//            String currentUserCitycode = userInfo.getCitycode();
//            List<String> childCodes = new ArrayList<>();
//
//            if (StringUtils.hasText(citycode) && !citycode.equals(currentUserCitycode)) {
//                // 检查城市码是否在考评范围内
//                List<String> parentCodes = cityMapper.selectChildrenCodesByCode(currentUserCitycode);
//                boolean exist = parentCodes.contains(citycode);
//                if (!exist) {
//                    return Result.error("该地区码不在考评范围内");
//                }
//
//                // 获取子区域代码
//                childCodes.addAll(cityMapper.selectChildrenCodesByCode(citycode));
//                childCodes.add(citycode);
//            }
//
//            // 查询学生照片数据
//            List<StudentListData> studentList = studentMapper.selectStudentPicList(taskId, childCodes);
//
//            if (studentList.isEmpty()) {
//                return Result.error("该考务尚未上传图片");
//            }
//
//            // 创建临时目录
//            String tmpDir = "pic/task_" + taskId;
//            String tempDirPath = fileConfig.getExportDir() + "/" + tmpDir;
//            java.nio.file.Path tempDir = java.nio.file.Paths.get(tempDirPath);
//            if (!java.nio.file.Files.exists(tempDir)) {
//                java.nio.file.Files.createDirectories(tempDir);
//            }
//
//            // 下载图片文件并按学校分组
//            Map<String, List<StudentListData>> schoolMap = new HashMap<>();
//
//            for (StudentListData student : studentList) {
//                // 将学生添加到对应学校的列表中
//                String schoolName = student.getSchoolName() != null ? student.getSchoolName() : "未知学校";
//                if (!schoolMap.containsKey(schoolName)) {
//                    schoolMap.put(schoolName, new ArrayList<>());
//                }
//                schoolMap.get(schoolName).add(student);
//            }
//
//            // 生成zip文件
//            String zipFileName = java.util.UUID.randomUUID().toString() + ".zip";
//            String zipFilePath = tempDirPath + "/" + zipFileName;
//
//            try (java.util.zip.ZipOutputStream zipOut = new java.util.zip.ZipOutputStream(new java.io.FileOutputStream(zipFilePath))) {
//                for (Map.Entry<String, List<StudentListData>> entry : schoolMap.entrySet()) {
//                    String schoolName = entry.getKey();
//                    List<StudentListData> students = entry.getValue();
//
//                    for (StudentListData student : students) {
//                        // 获取图片文件名
//                        String picUrl = student.getPicUrl();
//                        if (picUrl != null && !picUrl.isEmpty()) {
//                            // 从URL中提取对象名称
//                            String objectName = extractObjectNameFromUrl(picUrl);
//
//                            if (objectName != null && !objectName.isEmpty()) {
//                                String fileName = java.nio.file.Paths.get(objectName).getFileName().toString();
//
//                                // 确定zip中的文件路径
//                                String zipEntryName = fileName;
//                                if (isAll != 1) {
//                                    zipEntryName = schoolName + "/" + fileName;
//                                }
//
//                                // 创建zip条目
//                                java.util.zip.ZipEntry zipEntry = new java.util.zip.ZipEntry(zipEntryName);
//                                zipOut.putNextEntry(zipEntry);
//
//                                // 从MinIO下载文件并写入zip
//                                try (InputStream in = minioUtil.getFileInputStream(objectName)) {
//                                    byte[] buffer = new byte[1024];
//                                    int len;
//                                    while ((len = in.read(buffer)) > 0) {
//                                        zipOut.write(buffer, 0, len);
//                                    }
//                                } catch (Exception e) {
//                                    log.warn("下载学生照片失败: {}", picUrl, e);
//                                }
//
//                                zipOut.closeEntry();
//                            }
//                        }
//                    }
//                }
//            }
//
//            // 返回文件访问URL
//            String url = fileConfig.getUrlPrefix() + "/" + tmpDir + "/" + zipFileName;
//            return Result.success(url);
//
//        } catch (Exception e) {
//            log.error("抽测考生照片导出失败", e);
//            return Result.error("照片导出失败：" + e.getMessage());
//        }
//    }
//
//    /**
//     * 从URL中提取对象名称
//     *
//     * @param url 完整的文件URL
//     * @return 对象名称
//     */
//    private String extractObjectNameFromUrl(String url) {
//        if (url == null || url.isEmpty()) {
//            return null;
//        }
//
//        try {
//            java.net.URL uri = new java.net.URL(url);
//            String path = uri.getPath();
//
//            // 移除前导斜杠
//            if (path.startsWith("/")) {
//                path = path.substring(1);
//            }
//
//            // 分割路径，获取存储桶后的部分
//            String[] parts = path.split("/", 2);
//            if (parts.length == 2) {
//                return parts[1]; // 返回对象名称部分
//            }
//        } catch (Exception e) {
//            log.warn("解析URL失败: {}", url, e);
//        }
//
//        return null;
//    }
//
//    /**
//     * 抽测考生替换
//     *
//     * @param taskId    任务id
//     * @param studentId 学生id
//     * @return 替换结果
//     */
//    @Transactional(rollbackFor = Exception.class)
//    public Result<StudentListData> ccStudentReplace(Integer taskId, Integer studentId) {
//        try {
//            // 验证参数
//            if (taskId == null || taskId <= 0) {
//                return Result.error("任务id参数不正确");
//            }
//
//            if (studentId == null || studentId <= 0) {
//                return Result.error("学生id参数不正确");
//            }
//
//            // 检查任务状态
//            Task task = taskService.getById(taskId);
//            if (task == null) {
//                return Result.error("任务不存在");
//            }
//
//            if (task.getStudentState() != 2) {
//                return Result.error("仅抽签后才可替换！");
//            }
//
//            if (task.getState() == 1 && task.getStartAt() != null && task.getStartAt() < System.currentTimeMillis() / 1000) {
//                return Result.error("考试已经开始，不可操作！");
//            }
//
//            // 获取学生信息
//            Student stuInfo = studentMapper.selectById(studentId);
//            if (stuInfo == null) {
//                return Result.error("找不到对应学生！");
//            }
//
//            if (stuInfo.getState() != 1) {
//                return Result.error("对应学生并未被抽中！");
//            }
//
//            // 获取与学生相同学校、相同等级的学生
//            LambdaQueryWrapper<Student> studentWrapper = new LambdaQueryWrapper<>();
//            studentWrapper.eq(Student::getTaskId, taskId);
//            studentWrapper.eq(Student::getSchoolId, stuInfo.getSchoolId());
//            studentWrapper.eq(Student::getLevel, stuInfo.getLevel());
//            studentWrapper.eq(Student::getState, 0); // 未被抽中的学生
//            studentWrapper.eq(Student::getIsDeleted, 0);
//            List<Student> stuInfos = studentMapper.selectList(studentWrapper);
//
//            if (!stuInfos.isEmpty()) {
//                Random rand = new Random();
//                int index = rand.nextInt(stuInfos.size());
//
//                // 将原学生状态设置为未抽中
//                Student originalStudent = new Student();
//                originalStudent.setId(stuInfo.getId());
//                originalStudent.setState(0); // 未抽中
//                studentMapper.updateById(originalStudent);
//
//                // 将新学生状态设置为抽中
//                Student newStudent = stuInfos.get(index);
//                newStudent.setState(1); // 抽中
//                studentMapper.updateById(newStudent);
//
//                // 返回新学生信息
//                StudentListData studentListData = new StudentListData();
//                studentListData.setId(newStudent.getId());
//                studentListData.setName(newStudent.getName());
//                studentListData.setSchoolId(newStudent.getSchoolId());
//                studentListData.setStudentNo(newStudent.getStudentNo());
//                studentListData.setSex(newStudent.getSex());
//                studentListData.setGrade(newStudent.getGrade());
//                studentListData.setClazz(newStudent.getClazz());
//                studentListData.setLevel(newStudent.getLevel());
//                studentListData.setTaskId(newStudent.getTaskId());
//                studentListData.setState(newStudent.getState());
//                studentListData.setPicUrl(newStudent.getPicUrl());
//                if (newStudent.getFaceId() != null) {
//                    studentListData.setFaceId(String.valueOf(newStudent.getFaceId())); // 转换为String
//                }
//
//                return Result.success(studentListData);
//            } else {
//                // 没有可替换的学生，返回原学生信息
//                StudentListData studentListData = new StudentListData();
//                studentListData.setId(stuInfo.getId());
//                studentListData.setName(stuInfo.getName());
//                studentListData.setSchoolId(stuInfo.getSchoolId());
//                studentListData.setStudentNo(stuInfo.getStudentNo());
//                studentListData.setSex(stuInfo.getSex());
//                studentListData.setGrade(stuInfo.getGrade());
//                studentListData.setClazz(stuInfo.getClazz());
//                studentListData.setLevel(stuInfo.getLevel());
//                studentListData.setTaskId(stuInfo.getTaskId());
//                studentListData.setState(stuInfo.getState());
//                studentListData.setPicUrl(stuInfo.getPicUrl());
//                if (stuInfo.getFaceId() != null) {
//                    studentListData.setFaceId(String.valueOf(stuInfo.getFaceId())); // 转换为String
//                }
//
//                return Result.success(studentListData);
//            }
//
//        } catch (Exception e) {
//            log.error("抽测考生替换失败", e);
//            return Result.error("替换失败：" + e.getMessage());
//        }
//    }
}